package Principal;


import java.io.*;
import java.util.*;
import java.util.Calendar;
import javax.microedition.midlet.*;
import java.lang.*;
import javax.microedition.lcdui.*;
import javax.microedition.rms.*;

/**
 * MIDlet Wallet. Clase lanzadora de la aplicación.
 * @author Noelia Alonso Garrido
 * @author Abel Torres Alonso
 * @author Diego Vallejo Alonso
 */
public class Wallet extends MIDlet implements CommandListener {

    Display pantalla;
    List pantallaInicial;   //Pantalla inicial de la aplicación
    Command cSalir, cAnadir, cRanking, cVerMonedas, cBorrarTodos, cVerTotal; //Comandos de la pantalla Inicial
    List listaOpGastos;
    Alert alertaEliminarGasto;
    Command cEditar; //Comando para editar un gasto;
    Form pantallaAnadir;    //Pantalla para añadir nuevos gastos
    Command cVolver, cAnadir2, cAceptar;
    List pantallaRanking; //Pantalla para mostrar el ranking
    Command cFechas;
    List listaMonedas; //Pantalla para ver las monedas
    Command cActualizar;
    Command cNuevaMoneda;
    List listaOpMonedas;
    Command cVolverL;
    boolean actualizadaM = true; //para llevar el control de las actualizaciones en el registro de monedas y gastos
    boolean actualizadaG = true;
    boolean actualizadaGC = true;
    Alert alertaActualizar;
    Alert alertaEliminarMoneda;
    Alert alertaErrorBorrar;
    int[] idMonedas, idGastos, idGastosC; //Con este vector ajustamos la referencia de monedas y gastos en el registro y sus referencias en las listas
    Form formularioNuevaMoneda;
    Alert alertaErrorAnadir;
    TextField campoNombre, campoCodigo;
    Alert alertaCambiarReferencia;
    Alert alertaBorrarTodos; //Alerta para cuando el usuario quiera borrar todos sus gastos
    Command cCancelar, cOK;
    Alert alertaGastosTotales; //Alerta para mostrar al usuario el total de gastos
    private RegistroMonedas rMonedas; //Para acceder al registro donde se guardarán los datos de las monedas
    ChoiceGroup Lmonedas;
    TextField categoria, cantidad;
    String cadenaFecha, cat, cant, m; //Para el formulario de nuevo gasto
    float quantity;
    Date fechaActual;
    DateField fecha;
    private RegistroGastos rGastos;
    String listaMostrada;
    String orden;
    private int dia, mes, anio;
    Alert alertaActualizando;
    boolean actualizarTodas = true;
    Date nueva;
    private String diaS;
    private String mesS;

    /**
     * Constructor de la clase.
     */
    public Wallet() {

        Moneda m;
        iniciarInterfaz();
        rMonedas = new RegistroMonedas();       //Abrimos el registro donde se guarda la información de las monedas
        rMonedas.abrirRegistroMonedas();
        try {
            m = rMonedas.extraeMoneda(1);       //Recuperamos la moneda de referencia
            Moneda.setReferencia(m.getReferencia());
            System.out.println("Referencia: " + m.getReferencia());
        } catch (RecordStoreNotOpenException ex) {
            ex.printStackTrace();
        } catch (InvalidRecordIDException ex) {
            ex.printStackTrace();
        } catch (RecordStoreException ex) {
            ex.printStackTrace();
        }
        rGastos = new RegistroGastos();       //Abrimos el registro donde se guarda la información de las monedas
        rGastos.abrirRegistroGastos();

    }

    /**
     * Inicialización de toda la interfaz.
     */
    private void iniciarInterfaz() {
        /* Inicialización de las diferentes variables de la interfaz gráfica */

        pantalla = Display.getDisplay(this);
        cSalir = new Command("Salir", Command.EXIT, 1);
        cAnadir = new Command("Añadir", Command.SCREEN, 1);
        cRanking = new Command("Ranking", Command.SCREEN, 1);
        cVerMonedas = new Command("Ver Monedas", Command.SCREEN, 1);
        cBorrarTodos = new Command("Borrar Todos", Command.SCREEN, 1);
        cVerTotal = new Command("Ver Total", Command.SCREEN, 1);

        /* Pantalla inicial */

        pantallaInicial = new List("Lista de gastos", List.IMPLICIT);
        pantallaInicial.addCommand(cSalir);
        pantallaInicial.addCommand(cAnadir);
        pantallaInicial.addCommand(cRanking);
        pantallaInicial.addCommand(cVerMonedas);
        pantallaInicial.addCommand(cBorrarTodos);
        pantallaInicial.addCommand(cVerTotal);
        pantallaInicial.setCommandListener(this);

        /* Lista de opciones sobre cada gasto */
        cVolver = new Command("Volver", Command.BACK, 1);
        listaOpGastos = new List("Gestión de gasto", List.IMPLICIT);
        listaOpGastos.addCommand(cVolver);
        listaOpGastos.setCommandListener(this);
        listaOpGastos.insert(listaOpGastos.size(), "Editar", null);
        listaOpGastos.insert(listaOpGastos.size(), "Eliminar", null);

        /* Pantalla de añadir nuevo gasto */

        pantallaAnadir = new Form("Añadir nuevo gasto");
        pantallaAnadir.addCommand(cAnadir);
        pantallaAnadir.addCommand(cVolver);
        pantallaAnadir.setCommandListener(this);

        /*Para introducir la fecha*/
        fechaActual = new Date();
        fecha = new DateField("Fecha", DateField.DATE);
        fecha.setDate(fechaActual); //en fecha es donde se nos deberia de guardar la fecha que vamos a introducir
        pantallaAnadir.append(fecha);

        /*Introducir categoria*/
        categoria = new TextField("Categoria", "", 25, TextField.ANY);
        pantallaAnadir.append(categoria);

        /*Introducir cantidad*/
        cantidad = new TextField("Cantidad", "", 10, TextField.DECIMAL);
        pantallaAnadir.append(cantidad);

        /* Alerta para eliminar el gasto */

        cCancelar = new Command("Cancelar", Command.CANCEL, 1);
        cOK = new Command("OK", Command.OK, 1);

        alertaEliminarGasto = new Alert("Borrar gasto", "¿Seguro que desea eliminar este gasto? Esta operación no puede deshacerse", null, AlertType.CONFIRMATION);
        alertaEliminarGasto.addCommand(cCancelar);
        alertaEliminarGasto.addCommand(cOK);
        alertaEliminarGasto.setCommandListener(this);

        /* Items para la edición de gastos */

        cEditar = new Command("Guardar", Command.SCREEN, 1);

        /* Pantalla para el ranking */

        cFechas = new Command("Ordenar por Fechas", Command.SCREEN, 1);
        pantallaRanking = new List("Ranking de gastos", List.IMPLICIT);
        pantallaRanking.addCommand(cSalir);
        pantallaRanking.addCommand(cAnadir);
        pantallaRanking.addCommand(cFechas);
        pantallaRanking.addCommand(cVerMonedas);
        pantallaRanking.addCommand(cBorrarTodos);
        pantallaRanking.addCommand(cVerTotal);
        pantallaRanking.setCommandListener(this);

        /* Pantalla para ver las monedas */

        cActualizar = new Command("Actualizar Todas", Command.SCREEN, 1);
        cNuevaMoneda = new Command("Nueva moneda", Command.SCREEN, 1);
        listaMonedas = new List("Lista de monedas", List.IMPLICIT);
        listaMonedas.addCommand(cVolver);
        listaMonedas.addCommand(cActualizar);
        listaMonedas.addCommand(cNuevaMoneda);
        listaMonedas.setCommandListener(this);

        listaOpMonedas = new List("Gestión de monedas", List.IMPLICIT);
        listaOpMonedas.addCommand(cVolver);
        listaOpMonedas.insert(listaOpMonedas.size(), "Actualizar", null);
        listaOpMonedas.insert(listaOpMonedas.size(), "Eliminar", null);
        listaOpMonedas.insert(listaOpMonedas.size(), "Establecer como Referencia", null);
        listaOpMonedas.setCommandListener(this);

        alertaActualizar = new Alert("Actualizar", "La actualización requiere una conexión a internet que puede implicar gastos adicionales. ¿Seguro que desea actualizar?", null, AlertType.CONFIRMATION);
        alertaActualizar.addCommand(cCancelar);
        alertaActualizar.addCommand(cOK);
        alertaActualizar.setCommandListener(this);

        alertaEliminarMoneda = new Alert("Borrar moneda", "¿Seguro que desea eliminar esta moneda? Esta operación no puede deshacerse", null, AlertType.CONFIRMATION);
        alertaEliminarMoneda.addCommand(cCancelar);
        alertaEliminarMoneda.addCommand(cOK);
        alertaEliminarMoneda.setCommandListener(this);
        alertaErrorBorrar = new Alert("Error al eliminar", null, null, AlertType.ERROR);
        alertaErrorBorrar.addCommand(cVolver);
        alertaErrorBorrar.setCommandListener(this);

        formularioNuevaMoneda = new Form("Añadir nueva moneda");
        campoNombre = new TextField("Nombre:", null, 15, 0);
        campoCodigo = new TextField("Código:", null, 3, 0);
        formularioNuevaMoneda.append(campoNombre);
        formularioNuevaMoneda.append(campoCodigo);
        formularioNuevaMoneda.addCommand(cVolver);
        formularioNuevaMoneda.addCommand(cAnadir);
        formularioNuevaMoneda.setCommandListener(this);

        alertaErrorAnadir = new Alert("Error al añadir moneda", null, null, AlertType.ERROR);
        alertaErrorAnadir.addCommand(cVolver);
        alertaErrorAnadir.setTimeout(Alert.FOREVER);
        alertaErrorAnadir.setCommandListener(this);

        alertaCambiarReferencia = new Alert("Cambiar moneda de referencia.", "¿Seguro que desea establecer esta moneda como referencia? Será necesario actualizar las equivalencias de todas las demás a través de Internet, lo cual podría implicar gastos adicionales", null, AlertType.CONFIRMATION);
        alertaCambiarReferencia.addCommand(cCancelar);
        alertaCambiarReferencia.addCommand(cOK);
        alertaCambiarReferencia.setCommandListener(this);

        /* Alerta para mostrar cuando el usuario quiere borrar todos los mensajes */

        alertaBorrarTodos = new Alert("Borrar todos los gastos", "¿Seguro que quiere borrar todos los gastos?", null, AlertType.CONFIRMATION);
        alertaBorrarTodos.setTimeout(Alert.FOREVER);
        alertaBorrarTodos.addCommand(cCancelar);
        alertaBorrarTodos.addCommand(cOK);
        alertaBorrarTodos.setCommandListener(this);

        /* Alerta para mostrar al usuario el total de gastos */

        alertaGastosTotales = new Alert("Gastos Totales", null, null, AlertType.INFO);
        alertaGastosTotales.addCommand(cOK);
        alertaGastosTotales.setTimeout(Alert.FOREVER);
        alertaGastosTotales.setCommandListener(this);
        alertaActualizando = new Alert("Actualizando", null, null, AlertType.INFO);
        alertaActualizando.setTimeout(Alert.FOREVER);
        alertaActualizando.setCommandListener(this);
    }

    /**
     * Lanzamiento del SplasScreen.
     */
    public void startApp() {
        if (pantalla == null) {
            pantalla = Display.getDisplay(this);
        }
        pantalla.setCurrent(new SplashScreen(this));
    }

    /**
     * Invocada desde el SplashScreen para inciar la aplicación.
     */
    public void iniciar() {
        new Thread(new Tiempo(this)).start();
        startApp2();
    }

    /**
     * Establece la pantalla inicial de la aplicación.
     */
    public void startApp2() {
        llenarListaGastos();
        listaMostrada = "pantallaInicial";
        orden = "fecha";
        pantalla.setCurrent(pantallaInicial);
    }

    public void pauseApp() {
    }

    public void destroyApp(boolean unconditional) {
        rMonedas.cierraRegistro();      //Cerramos el registro de las monedas
        rGastos.cierraRegistroGastos();      //Cerramos el registro de gastos
    }

    public void commandAction(Command c, Displayable d) {

        if (c == cSalir) {
            destroyApp(false);
            notifyDestroyed();
        }

        if (c == cAnadir) {
            if (d == formularioNuevaMoneda) {
                if (!anadir()) {
                    pantalla.setCurrent(alertaErrorAnadir);
                } else {
                    listaMostrada = "listaMonedas";
                    pantalla.setCurrent(listaMonedas);
                }
            } else if ((d == pantallaInicial) || (d == pantallaRanking)) {
                pantallaAnadir.setTitle("Añadir un nuevo Gasto");
                if (pantallaAnadir.size() > 3) {
                    pantallaAnadir.delete(3);
                }
                categoria.setString("");
                cantidad.setString("");
                fecha.setDate(fechaActual);
                Lmonedas = new ChoiceGroup("Lista Monedas", ChoiceGroup.POPUP, getListaMonedas(), null);
                for (int contador = 0; contador < getListaMonedas().length; contador++) {    //Dejamos seleccionada en la lista de monedas la de referencia
                    if (Lmonedas.getString(contador).equals(Moneda.getReferencia())) {
                        Lmonedas.setSelectedIndex(contador, true);
                    }
                }
                pantallaAnadir.append(Lmonedas);
                pantalla.setCurrent(pantallaAnadir);

            } else if (d == pantallaAnadir) {
                /* Cuando se da la orden de añadir un nuevo gasto desde el formulario de nuevo gasto, hay que recuperar cada uno
                 * de los datos introducidos por el usuario y generar con ellos un nuevo gasto. Después ese gasto se guarda en el
                 * registro de gastos
                 */

                Calendar calendar = Calendar.getInstance();
                calendar.setTime(fecha.getDate());
                dia = calendar.get(Calendar.DAY_OF_MONTH);   //dia del mes
                mes = calendar.get(Calendar.MONTH);  //mes, de 0 a 11
                mes = mes + 1;
                anio = calendar.get(Calendar.YEAR);  //año

                cat = categoria.getString();//metemos lo de textField en una variable tipo string
                cant = cantidad.getString();//metemos lo de textField en una variable tipo string
                float q = 0;
                try {
                    q = Float.parseFloat(cant); //transformamos un string a float
                } catch (Exception e) {
                    System.out.println("Error al transformar a float");
                }
                m = Lmonedas.getString(Lmonedas.getSelectedIndex());// tendriamos en m el codigo de la moneda
                Gasto g = new Gasto(dia, mes, anio, cat, q, m);
                Moneda mon = rMonedas.buscarMoneda(g.getCodigo());
                if (mon != null) {
                    g.setCantidadEquivalente(mon.cantidadEquivalente(g.getCantidad()));
                    g.setActualizado(true);
                }
                rGastos.insertarGasto(g);
                actualizadaG = true;
                actualizadaGC = true;
                if (listaMostrada.equals("pantallaInicial")) {
                    llenarListaGastos();
                    pantalla.setCurrent(pantallaInicial);
                } else {
                    llenarListaGastosC();
                    pantalla.setCurrent(pantallaRanking);
                }
            }
        }

        if (c == cRanking) {
            llenarListaGastosC();
            listaMostrada = "pantallaRanking";
            orden = "cantidad";
            pantalla.setCurrent(pantallaRanking);
        }

        if (c == cVerMonedas) {
            llenarListaMonedas();
            listaMostrada = "listaMonedas";
            pantalla.setCurrent(listaMonedas);
        }

        if (c == cBorrarTodos) {
            pantalla.setCurrent(alertaBorrarTodos, pantallaInicial);
        }

        if (c == cVerTotal) {
            String linea = "Gastos Totales: " + verTotal() + " " + Moneda.getReferencia();
            alertaGastosTotales.setString(linea);
            pantalla.setCurrent(alertaGastosTotales);
        }

        if (c == cFechas) {
            listaMostrada = "pantallaInicial";
            orden = "fecha";
            llenarListaGastos();
            pantalla.setCurrent(pantallaInicial);
        }

        if (c == cVolver) {
            if ((d == listaOpMonedas) || (d == formularioNuevaMoneda) || (d == alertaErrorBorrar)) {
                listaMostrada = "listaMonedas";
                pantalla.setCurrent(listaMonedas);
            } else if (d == alertaErrorAnadir) {
                pantalla.setCurrent(formularioNuevaMoneda);
            } else if (d == pantallaAnadir) {
                pantallaAnadir.removeCommand(cEditar);  //reutilizado para editar un gasto.
                pantallaAnadir.addCommand(cAnadir);
                pantallaAnadir.setTitle("Añadir un nuevo gasto");
                if (orden.equals("cantidad")) {
                    listaMostrada = "pantallaRanking";
                    pantalla.setCurrent(pantallaRanking);
                } else {
                    listaMostrada = "pantallaInicial";
                    pantalla.setCurrent(pantallaInicial);
                }
            } else if (orden.equals("cantidad")) {
                listaMostrada = "pantallaRanking";
                pantalla.setCurrent(pantallaRanking);
            } else {
                listaMostrada = "pantallaInicial";
                pantalla.setCurrent(pantallaInicial);
            }
        }
        if (c == cActualizar) {
            pantalla.setCurrent(alertaActualizar);
        }

        if (c == cOK) {
            if (d == alertaActualizar) {
                if (!actualizarTodas) { //Si el usuario ha elegido actualizar sólo una moneda:
                    try {
                        Moneda m = rMonedas.extraeMoneda(idMonedas[listaMonedas.getSelectedIndex()]);
                        if (m != null) {
                            HiloActualizador h = new HiloActualizador(m);    //Creamos un hilo para actualizar la moneda
                            Thread hilo = new Thread(h);
                            hilo.start();
                            while (!h.terminado) {      //Esperamos a que termine
                                Thread.sleep(50);
                            }
                            if (h.exito) {
                                rMonedas.reemplazaMoneda(m, idMonedas[listaMonedas.getSelectedIndex()]);    //Si ha conseguido actualizar, reemplazamos por la nueva moneda en el registro
                                actualizadaM = true;
                                llenarListaMonedas();
                            }
                        }
                    } catch (RecordStoreNotOpenException ex) {
                        ex.printStackTrace();
                    } catch (InvalidRecordIDException ex) {
                        ex.printStackTrace();
                    } catch (RecordStoreException ex) {
                        ex.printStackTrace();
                    } catch (InterruptedException ex) {
                        ex.printStackTrace();
                    }
                    actualizarTodas = true;
                } else {                //Si el usuario ha elegido actualizar todas las monedas:
                    actualizarMonedas();
                    actualizadaM = true;
                    llenarListaMonedas();
                }
                listaMostrada = "listaMonedas";
                pantalla.setCurrent(listaMonedas);
            } else if (d == alertaEliminarMoneda) {
                if (borrarMoneda(idMonedas[listaMonedas.getSelectedIndex()])) {
                    llenarListaMonedas();
                    listaMostrada = "listaMonedas";
                    pantalla.setCurrent(listaMonedas);
                } else {
                    pantalla.setCurrent(alertaErrorBorrar);
                }
            } else if (d == alertaCambiarReferencia) {
                cambiarMonedaReferencia(idMonedas[listaMonedas.getSelectedIndex()]);
                llenarListaMonedas();
                listaMostrada = "listaMonedas";
                pantalla.setCurrent(listaMonedas);
            } else if (d == alertaEliminarGasto) {
                if (orden.equals("fecha")) {
                    rGastos.borrarGasto(idGastos[pantallaInicial.getSelectedIndex()]);
                } else {
                    rGastos.borrarGasto(idGastosC[pantallaRanking.getSelectedIndex()]);
                }
                actualizadaG = true;
                actualizadaGC = true;
                llenarListaGastos();
                llenarListaGastosC();
                if (orden.equals("fecha")) {
                    listaMostrada = "pantallaInicial";
                    pantalla.setCurrent(pantallaInicial);
                } else {
                    listaMostrada = "pantallaRanking";
                    pantalla.setCurrent(pantallaRanking);
                }

            } else if (d == alertaBorrarTodos) {
                try {
                    RecordEnumeration re = rGastos.getEnumeracion();
                    while (re.hasPreviousElement()) {
                        rGastos.borrarGasto(re.previousRecordId());
                    }
                    actualizadaG = true;
                    actualizadaGC = true;

                    if (orden.equals("fecha")) {
                        llenarListaGastos();
                        listaMostrada = "pantallaInicial";
                        pantalla.setCurrent(pantallaInicial);
                    } else {
                        llenarListaGastosC();
                        listaMostrada = "pantallaRanking";
                        pantalla.setCurrent(pantallaRanking);
                    }

                } catch (InvalidRecordIDException ex) {
                    ex.printStackTrace();
                }

            } else if (d == alertaGastosTotales) {
                if (orden.equals("fecha")) {
                    listaMostrada = "pantallaInicial";
                    pantalla.setCurrent(pantallaInicial);
                } else {
                    listaMostrada = "pantallaRanking";
                    pantalla.setCurrent(pantallaRanking);
                }
            } else {
                llenarListaGastos();
                llenarListaGastosC();
                if (orden.equals("fecha")) {
                    listaMostrada = "pantallaInicial";
                    pantalla.setCurrent(pantallaInicial);
                } else {
                    listaMostrada = "pantallaRanking";
                    pantalla.setCurrent(pantallaRanking);
                }
            }
        }
        if (c == cCancelar) {
            if ((d == alertaActualizar) || (d == alertaEliminarMoneda) || (d == alertaCambiarReferencia)) {
                listaMostrada = "listaOpMonedas";
                pantalla.setCurrent(listaOpMonedas);
            } else {
                if (orden.equals("fecha")) {
                    listaMostrada = "pantallaInicial";
                    pantalla.setCurrent(pantallaInicial);
                } else {
                    listaMostrada = "pantallaRanking";
                    pantalla.setCurrent(pantallaRanking);
                }
            }
        }

        /* Opciones de selección para la lista de monedas */
        if (c == List.SELECT_COMMAND) {
            if (listaMostrada.equals("listaMonedas")) {
                listaMostrada = "listaOpMonedas";
                try { //La moneda de referencia no vuelve a mostrar como opción "Establecer como referencia"
                    Moneda m = rMonedas.extraeMoneda(idMonedas[listaMonedas.getSelectedIndex()]);
                    if (m.esReferencia() && (listaOpMonedas.size() > 2)){
                        listaOpMonedas.delete(2);
                    } else if(!m.esReferencia() && (listaOpMonedas.size() < 3)){
                        listaOpMonedas.insert(listaOpMonedas.size(), "Establecer como Referencia", null);
                    }
                } catch (RecordStoreNotOpenException ex) {
                    ex.printStackTrace();
                } catch (InvalidRecordIDException ex) {
                    ex.printStackTrace();
                } catch (RecordStoreException ex) {
                    ex.printStackTrace();
                }
                pantalla.setCurrent(listaOpMonedas);
            } else if (listaMostrada.equals("listaOpMonedas")) {
                switch (listaOpMonedas.getSelectedIndex()) {
                    case 0:
                        actualizarTodas = false;
                        pantalla.setCurrent(alertaActualizar);
                        break;  //Actualizar
                    case 1:
                        pantalla.setCurrent(alertaEliminarMoneda);
                        break;  //Eliminar
                    case 2:
                        alertaCambiarReferencia.setString("¿Seguro que desea establecer esta moneda como referencia? Será necesario actualizar las equivalencias de todas las demás a través de Internet, lo cual podría implicar gastos adicionales");
                        pantalla.setCurrent(alertaCambiarReferencia);
                        break;  //Poner como referencia
                    default:
                        listaMostrada = "listaOpMonedas";
                        pantalla.setCurrent(listaOpMonedas);
                        break;
                }
            } else if (listaMostrada.equals("pantallaInicial") || listaMostrada.equals("pantallaRanking")) {
                listaMostrada = "listaOpGastos";
                pantalla.setCurrent(listaOpGastos);
            } else if (listaMostrada.equals("listaOpGastos")) {
                switch (listaOpGastos.getSelectedIndex()) {
                    case 0:
                        System.out.println("Se seleccionó editar gasto");
                        pantallaAnadir.removeCommand(cAnadir);
                        pantallaAnadir.addCommand(cEditar);
                        pantallaAnadir.setTitle("Editar un gasto");
                        if (pantallaAnadir.size() > 3) {
                            pantallaAnadir.delete(3);
                        }
                        Lmonedas = new ChoiceGroup("Lista Monedas", ChoiceGroup.POPUP, getListaMonedas(), null);
                        pantallaAnadir.append(Lmonedas);
                        try {
                            Gasto g;
                            if (orden.equals("cantidad")) {//Extraemos el gasto a editar y ponemos sus datos en las etiquetas
                                g = rGastos.extraeGasto(idGastosC[pantallaRanking.getSelectedIndex()]);
                            } else {
                                g = rGastos.extraeGasto(idGastos[pantallaInicial.getSelectedIndex()]);
                            }
                            if (g != null) {
                                if (g.dia < 10) {
                                    diaS = "0" + g.dia;
                                } else {
                                    diaS = "" + g.dia;
                                }
                                if (g.mes < 10) {
                                    mesS = "0" + g.mes;
                                } else {
                                    mesS = "" + g.mes;
                                }
                                cadenaFecha = diaS + "-" + mesS + "-" + g.anio;
                                System.out.println(cadenaFecha);
                                nueva = g.getfecha(cadenaFecha); //obtiene la fecha del gasto almacenado
                                fecha.setDate(nueva);
                            }
                            cantidad.setString("" + g.getCantidad());
                            categoria.setString(g.getCategoria());

                            for (int contador = 0; contador < getListaMonedas().length; contador++) {    //Dejamos seleccionada en la lista de monedas la del gasto
                                if (Lmonedas.getString(contador).equals(g.getCodigo())) {
                                    Lmonedas.setSelectedIndex(contador, true);
                                }
                            }
                        } catch (RecordStoreNotOpenException ex) {
                            ex.printStackTrace();
                        } catch (InvalidRecordIDException ex) {
                            ex.printStackTrace();
                        } catch (RecordStoreException ex) {
                            ex.printStackTrace();
                        }
                        pantalla.setCurrent(pantallaAnadir);
                        break;
                    case 1:
                        System.out.println("Se seleccionó eliminar gasto"); //Eliminar
                        pantalla.setCurrent(alertaEliminarGasto);
                        break;
                }
            }
        }

        if (c == cEditar) {
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(fecha.getDate());
            dia = calendar.get(Calendar.DAY_OF_MONTH);   //dia del mes
            mes = calendar.get(Calendar.MONTH);  //mes, de 0 a 11
            mes = mes + 1;
            anio = calendar.get(Calendar.YEAR);  //año*/

            cat = categoria.getString();//metemos lo de textField en una variable tipo string
            cant = cantidad.getString();//metemos lo de textField en una variable tipo string
            System.out.println(cadenaFecha);

            float q = 0;
            try {
                q = Float.parseFloat(cant); //transformamos un string a float
            } catch (Exception e) {
                System.out.println("Error al transformar a float");
            }
            m = Lmonedas.getString(Lmonedas.getSelectedIndex());// tendriamos en m el codigo de la moneda
            Gasto gas = new Gasto(dia, mes, anio, cat, q, m);   //Como añadimos un nuevo gasto, su valor equivalente ha cambiado
            Moneda mon = rMonedas.buscarMoneda(m);              //y hay que obtenerlo.
            if (mon != null) {
                gas.setCantidadEquivalente(mon.cantidadEquivalente(gas.cantidad));
            }
            if (orden.equals("fecha")) {
                rGastos.reemplazaGasto(gas, idGastos[pantallaInicial.getSelectedIndex()]);
            } else {
                rGastos.reemplazaGasto(gas, idGastosC[pantallaRanking.getSelectedIndex()]);
            }
            actualizadaG = true;
            actualizadaGC = true;
            llenarListaGastos();
            llenarListaGastosC();
            if (orden.equals("fecha")) {
                listaMostrada = "pantallaInicial";
                pantalla.setCurrent(pantallaInicial);   //Reestablecemos las opciones de la pantalla añadir, que habíamos
            } else {
                listaMostrada = "pantallaRanking";
                pantalla.setCurrent(pantallaRanking);
            }
            pantallaAnadir.removeCommand(cEditar);  //reutilizado para editar un gasto.
            pantallaAnadir.addCommand(cAnadir);
            pantallaAnadir.setTitle("Añadir un nuevo gasto");
        }

        if (c == cNuevaMoneda) {
            campoNombre.setString(null);
            campoCodigo.setString(null);
            pantalla.setCurrent(formularioNuevaMoneda);
        }

        if (c == cAnadir2) {
            pantalla.setCurrent(pantallaAnadir);
        }
    }

    /**
     * Lee todas las monedas que hay en el registro de monedas y las inserta en una lista
     * implícita lista para mostrar por pantalla.
     */
    private void llenarListaMonedas() {
        int id;
        Moneda m;

        if (actualizadaM) {
            try {
                listaMonedas.deleteAll();
                RecordEnumeration re = rMonedas.getEnumeracion();
                idMonedas = new int[rMonedas.contarMonedas()];
                while (re.hasPreviousElement()) {
                    id = re.previousRecordId();
                    m = rMonedas.extraeMoneda(id);
                    if (m != null) {
                        idMonedas[listaMonedas.size()] = id;
                        listaMonedas.insert(listaMonedas.size(), m.toString(), null);
                    }
                }
                actualizadaM = false;
            } catch (RecordStoreNotOpenException ex) {
                ex.printStackTrace();
            } catch (InvalidRecordIDException ex) {
                ex.printStackTrace();
            } catch (RecordStoreException ex) {
                ex.printStackTrace();
            }
        }
    }

    /**
     * Proporciona un String con todos los códigos de moneda almacenados en el registro de monedas. Es
     * útil para llenar la lista de monedas en la pantalla de nuevo gasto.
     * @return un String con los códigos de moneda de cada una de las monedas almacenadas en el registro.
     */
    private String[] getListaMonedas() {
        try {
            String[] vector;
            String codigo;
            int id;
            int tamano;
            int contador = 0;
            Moneda m;
            tamano = rMonedas.contarMonedas();
            vector = new String[tamano];
            RecordEnumeration re = rMonedas.getEnumeracion();

            while (re.hasPreviousElement()) {
                id = re.previousRecordId();
                m = rMonedas.extraeMoneda(id);
                if (m != null) {
                    codigo = m.getCodigo();
                    vector[contador] = codigo;
                    contador++;
                }
            }
            return vector;
        } catch (RecordStoreNotOpenException ex) {
            ex.printStackTrace();
        } catch (InvalidRecordIDException ex) {
            ex.printStackTrace();
        } catch (RecordStoreException ex) {
            ex.printStackTrace();
        }
        return null;
    }

    /**
     * Elimina del registro la moneda en la posición indicada. No se pueden borrar las monedas
     * por defecto ni tampoco la moneda de referencia.
     * @param posicion La posición del registro de monedas que se quiera borrar
     * @return  true si se ha borrado, false si no.
     */
    private boolean borrarMoneda(int posicion) {
        System.out.println("Se entró en borrar moneda con posición: " + posicion);
        if ((posicion >= 1) && (posicion <= 6)) {
            alertaErrorBorrar.setString("No se pueden borrar las monedas por defecto");
            System.out.println("No se pueden borrar las monedas por defecto");
            return false;
        } else {
            Moneda m;
            try {
                m = rMonedas.extraeMoneda(posicion);
                if (m.esReferencia()) {
                    alertaErrorBorrar.setString("No se puede eliminar la moneda de referencia");
                    System.out.println("No se puede borrar (es referencia)");
                    return false;
                } else {
                    System.out.println("Sí se puede borrar");
                    rMonedas.borrarMoneda(posicion);
                    actualizadaM = true;
                    return true;
                }
            } catch (RecordStoreNotOpenException ex) {
                ex.printStackTrace();
            } catch (InvalidRecordIDException ex) {
                ex.printStackTrace();
            } catch (RecordStoreException ex) {
                ex.printStackTrace();
            }
        }
        return false;
    }

    /**
     * Añade una nueva moneda al registro de monedas a partir de los datos que el usuario
     * introduce en el formulario "Añadir Moneda".
     * @return true si se ha podido añadir, false en caso contrario.
     */
    private boolean anadir() {
        float equivalencia = 1;

        if (campoNombre.getString().equals("")) {                   //Comprobamos que el usuario haya escrito algo en el nombre
            alertaErrorAnadir.setString("No hay texto en el nombre");
            return false;
        } else {
            if (campoCodigo.getString().length() != 3) {            //Comprobamos que el código tenga 3 caracteres
                alertaErrorAnadir.setString("El cógido de moneda ha de tener 3 caracteres");
                return false;
            } else {
                Moneda m = rMonedas.buscarMoneda(campoCodigo.getString());
                if (m != null) {
                    alertaErrorAnadir.setString("Ya hay una moneda con ese código guardada");
                    return false;
                } else {
                    m = new Moneda(campoNombre.getString(), campoCodigo.getString(), (float) 1);
                    HiloActualizador h = new HiloActualizador(m);    //Creamos un hilo para actualizar la moneda
                    Thread hilo = new Thread(h);
                    hilo.start();

                    while (!h.terminado) {      //Esperamos a que termine
                        try {
                            //Esperamos a que termine
                            Thread.sleep(50);
                        } catch (InterruptedException ex) {
                            ex.printStackTrace();
                        }
                    }
                    if (h.exito) {
                        //Si ha conseguido actualizar, reemplazamos por la nueva moneda en el registro
                        if (m.getEquivalencia() == 0) {        //Comprobamos que el código exista obteniendo su equivalencia con la moneda de referencia
                            alertaErrorAnadir.setString("El cógido de moneda no existe");
                            return false;
                        } else {    //Todo ha ido bien, creamos la moneda y la insertamos en el registro.
                            rMonedas.insertaMoneda(m);
                            actualizadaM = true;
                            llenarListaMonedas();
                            return true;
                        }
                    } else {
                        alertaErrorAnadir.setString("No ha sido posible verificar el código en Internet");
                        return false;
                    }
                }
            }
        }
    }

    /**
     * Cambia la moneda de referencia. Actualiza las monedas guardadas en el registro.
     * @param codigo El código de la nueva equivalencia.
     */
    private void cambiarMonedaReferencia(int pos) {
        Moneda m;
        Gasto g;
        int id;
        String codigo;
        HiloActualizador h;
        Thread hilo;

        try {
            m = rMonedas.extraeMoneda(pos);
            codigo = m.getCodigo();
            RecordEnumeration re = rMonedas.getEnumeracion();

            while (re.hasPreviousElement()) {
                id = re.previousRecordId();
                m = rMonedas.extraeMoneda(id);
                Moneda.setReferencia(codigo);

                h = new HiloActualizador(m);    //Creamos un hilo para actualizar la moneda
                hilo = new Thread(h);
                hilo.start();

                while (!h.terminado) {      //Esperamos a que termine
                    Thread.sleep(50);
                }
                if (h.exito) {
                    rMonedas.reemplazaMoneda(m, id);    //Si ha conseguido actualizar, reemplazamos por la nueva moneda en el registro
                }
            }
            actualizadaM = true;

            /*
             * Como cambiamos la moneda de referencia, todos los gastos dejan de estar
             * actualizados.
             */

            re = rGastos.getEnumeracion();

            while (re.hasPreviousElement()) {
                id = re.previousRecordId();
                g = rGastos.extraeGasto(id);
                m = rMonedas.buscarMoneda(g.getCodigo());
                if (m != null) {
                    g.setCantidadEquivalente(m.cantidadEquivalente(g.getCantidad()));   //convertimos la cantidad en a la moneda de referencia y la almacenamos
                    g.setActualizado(true);
                } else {
                    g.setActualizado(false);
                }
                rGastos.reemplazaGasto(g, id);
            }
            actualizadaG = true;

        } catch (RecordStoreNotOpenException ex) {
            ex.printStackTrace();
        } catch (InvalidRecordIDException ex) {
            ex.printStackTrace();
        } catch (RecordStoreException ex) {
            ex.printStackTrace();
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
    }

    /**
     * Actualiza todas las monedas almacenadas en el registro de monedas.
     */
    private void actualizarMonedas() {
        Moneda m;
        int id;
        String codigo;
        HiloActualizador h;
        Thread hilo;

        RecordEnumeration re = rMonedas.getEnumeracion();

        try {
            while (re.hasPreviousElement()) {
                id = re.previousRecordId();
                m = rMonedas.extraeMoneda(id);

                h = new HiloActualizador(m); //Creamos un hilo para actualizar la moneda
                hilo = new Thread(h);
                hilo.start();
                while (!h.terminado) {
                    //Esperamos a que termine
                    Thread.sleep(50);
                }
                if (h.exito) {
                    rMonedas.reemplazaMoneda(m, id); //Si ha conseguido actualizar, reemplazamos por la nueva moneda en el registro
                }
            }
        } catch (RecordStoreNotOpenException ex) {
            ex.printStackTrace();
        } catch (InvalidRecordIDException ex) {
            ex.printStackTrace();
        } catch (RecordStoreException ex) {
            ex.printStackTrace();
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
    }

    /**
     * Lee todas las monedas que hay en el registro de monedas y las inserta en una lista
     * implícita lista para mostrar por pantalla ordenada por fecha
     */
    private void llenarListaGastos() {
        int id;
        Gasto g;

        if (actualizadaG) {
            try {
                pantallaInicial.deleteAll();
                RecordEnumeration re = rGastos.getEnumeracion();
                idGastos = new int[rGastos.contarGastos()];
                if (rGastos.contarGastos() == 0) {
                    pantallaInicial.setTitle("Lista de gastos (vacía)");
                } else {
                    pantallaInicial.setTitle("Lista de gastos");
                }
                while (re.hasPreviousElement()) {
                    id = re.previousRecordId();
                    g = rGastos.extraeGasto(id);
                    if (g != null) {
                        idGastos[pantallaInicial.size()] = id;
                        pantallaInicial.insert(pantallaInicial.size(), g.toString(), null);
                    }
                }
                actualizadaG = false;

            } catch (RecordStoreNotOpenException ex) {
                ex.printStackTrace();
            } catch (InvalidRecordIDException ex) {
                ex.printStackTrace();
            } catch (RecordStoreException ex) {
                ex.printStackTrace();
            }
        }
    }

    /**
     * Lee todas las monedas que hay en el registro de monedas y las inserta en una lista
     * implícita lista para mostrar por pantalla ordenada por fecha
     */
    private void llenarListaGastosC() {
        int id;
        Gasto g;

        if (actualizadaGC) {
            try {
                pantallaRanking.deleteAll();
                RecordEnumeration re = rGastos.getEnumeracionC();
                idGastosC = new int[rGastos.contarGastos()];
                if (rGastos.contarGastos() == 0) {
                    pantallaRanking.setTitle("Ranking de gastos (vacío)");
                } else {
                    pantallaRanking.setTitle("Ranking de gastos");
                }
                while (re.hasNextElement()) {
                    id = re.nextRecordId();
                    g = rGastos.extraeGasto(id);
                    if (g != null) {
                        idGastosC[pantallaRanking.size()] = id;
                        pantallaRanking.insert(pantallaRanking.size(), g.toString(), null);
                    }
                }
                actualizadaGC = false;

            } catch (RecordStoreNotOpenException ex) {
                ex.printStackTrace();
            } catch (InvalidRecordIDException ex) {
                ex.printStackTrace();
            } catch (RecordStoreException ex) {
                ex.printStackTrace();
            }
        }
    }

    /**
     * Muestra el total de gastos
     */
    private float verTotal() {
        int id;
        Gasto g;
        float total = 0;

        try {
            Moneda m;
            RecordEnumeration re = rGastos.getEnumeracion();
            while (re.hasPreviousElement()) {
                id = re.previousRecordId();
                g = rGastos.extraeGasto(id);
                if (g != null) {
                    if (g.getCodigo().equals(Moneda.getReferencia())) { //Si el gasto ya está en la moneda de referencia, simplemente sumamos su cantidad
                        total = total + g.getCantidad();
                    } else {    //El gasto no está en la moneda de referencia.
                        if (g.estaActualizado()) {                      //Si tiene su importe expresado en la moneda de referencia actual, lo sumamos
                            total = total + g.getCantidadEquivalente();
                        } else {    //el gasto no contiene su importe expresado en la moneda de referencia
                            m = rMonedas.buscarMoneda(g.getCodigo()); //buscamos la moneda en la que está expresado el gasto
                            if (m != null) {
                                g.setCantidadEquivalente(m.cantidadEquivalente(g.getCantidad()));   //convertimos la cantidad en a la moneda de referencia y la almacenamos
                                g.setActualizado(true);
                                total = total + g.getCantidadEquivalente();
                            }
                        }
                    }
                }
            }
            System.out.println("Gastos totales: " + total);
            return total;

        } catch (RecordStoreNotOpenException ex) {
            ex.printStackTrace();
        } catch (InvalidRecordIDException ex) {
            ex.printStackTrace();
        } catch (RecordStoreException ex) {
            ex.printStackTrace();
        }
        return (float) 0;
    }
}
